//===----------------------------------------------------------------------===//
//
// This source file is part of the Soto for AWS open source project
//
// Copyright (c) 2017-2024 the Soto project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Soto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//

// THIS FILE IS AUTOMATICALLY GENERATED by https://github.com/soto-project/soto-codegenerator.
// DO NOT EDIT.

#if canImport(FoundationEssentials)
import FoundationEssentials
#else
import Foundation
#endif
@_exported import SotoCore

/// Service object for interacting with AWS Greengrass service.
///
/// AWS IoT Greengrass seamlessly extends AWS onto physical devices so they can act locally on the data they generate, while still using the cloud for management, analytics, and durable storage. AWS IoT Greengrass ensures your devices can respond quickly to local events and operate with intermittent connectivity. AWS IoT Greengrass minimizes the cost of transmitting data to the cloud by allowing you to author AWS Lambda functions that execute locally.
public struct Greengrass: AWSService {
    // MARK: Member variables

    /// Client used for communication with AWS
    public let client: AWSClient
    /// Service configuration
    public let config: AWSServiceConfig

    // MARK: Initialization

    /// Initialize the Greengrass client
    /// - parameters:
    ///     - client: AWSClient used to process requests
    ///     - region: Region of server you want to communicate with. This will override the partition parameter.
    ///     - partition: AWS partition where service resides, standard (.aws), china (.awscn), government (.awsusgov).
    ///     - endpoint: Custom endpoint URL to use instead of standard AWS servers
    ///     - middleware: Middleware chain used to edit requests before they are sent and responses before they are decoded 
    ///     - timeout: Timeout value for HTTP requests
    ///     - byteBufferAllocator: Allocator for ByteBuffers
    ///     - options: Service options
    public init(
        client: AWSClient,
        region: SotoCore.Region? = nil,
        partition: AWSPartition = .aws,
        endpoint: String? = nil,
        middleware: AWSMiddlewareProtocol? = nil,
        timeout: TimeAmount? = nil,
        byteBufferAllocator: ByteBufferAllocator = ByteBufferAllocator(),
        options: AWSServiceConfig.Options = []
    ) {
        self.client = client
        self.config = AWSServiceConfig(
            region: region,
            partition: region?.partition ?? partition,
            serviceName: "Greengrass",
            serviceIdentifier: "greengrass",
            serviceProtocol: .restjson,
            apiVersion: "2017-06-07",
            endpoint: endpoint,
            serviceEndpoints: Self.serviceEndpoints,
            variantEndpoints: Self.variantEndpoints,
            errorType: GreengrassErrorType.self,
            middleware: middleware,
            timeout: timeout,
            byteBufferAllocator: byteBufferAllocator,
            options: options
        )
    }


    /// custom endpoints for regions
    static var serviceEndpoints: [String: String] {[
        "dataplane-us-gov-east-1": "greengrass-ats.iot.us-gov-east-1.amazonaws.com",
        "dataplane-us-gov-west-1": "greengrass-ats.iot.us-gov-west-1.amazonaws.com"
    ]}


    /// FIPS and dualstack endpoints
    static var variantEndpoints: [EndpointVariantType: AWSServiceConfig.EndpointVariant] {[
        [.fips]: .init(endpoints: [
            "ca-central-1": "greengrass-fips.ca-central-1.amazonaws.com",
            "us-east-1": "greengrass-fips.us-east-1.amazonaws.com",
            "us-east-2": "greengrass-fips.us-east-2.amazonaws.com",
            "us-gov-east-1": "greengrass.us-gov-east-1.amazonaws.com",
            "us-gov-west-1": "greengrass.us-gov-west-1.amazonaws.com",
            "us-west-2": "greengrass-fips.us-west-2.amazonaws.com"
        ])
    ]}

    // MARK: API Calls

    /// Associates a role with a group. Your Greengrass core will use the role to access AWS cloud services. The role's permissions should allow Greengrass core Lambda functions to perform actions against the cloud.
    @Sendable
    @inlinable
    public func associateRoleToGroup(_ input: AssociateRoleToGroupRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> AssociateRoleToGroupResponse {
        try await self.client.execute(
            operation: "AssociateRoleToGroup", 
            path: "/greengrass/groups/{GroupId}/role", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Associates a role with a group. Your Greengrass core will use the role to access AWS cloud services. The role's permissions should allow Greengrass core Lambda functions to perform actions against the cloud.
    ///
    /// Parameters:
    ///   - groupId: The ID of the Greengrass group.
    ///   - roleArn: The ARN of the role you wish to associate with this group. The existence of the role is not validated.
    ///   - logger: Logger use during operation
    @inlinable
    public func associateRoleToGroup(
        groupId: String,
        roleArn: String? = nil,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> AssociateRoleToGroupResponse {
        let input = AssociateRoleToGroupRequest(
            groupId: groupId, 
            roleArn: roleArn
        )
        return try await self.associateRoleToGroup(input, logger: logger)
    }

    /// Associates a role with your account. AWS IoT Greengrass will use the role to access your Lambda functions and AWS IoT resources. This is necessary for deployments to succeed. The role must have at least minimum permissions in the policy ''AWSGreengrassResourceAccessRolePolicy''.
    @Sendable
    @inlinable
    public func associateServiceRoleToAccount(_ input: AssociateServiceRoleToAccountRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> AssociateServiceRoleToAccountResponse {
        try await self.client.execute(
            operation: "AssociateServiceRoleToAccount", 
            path: "/greengrass/servicerole", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Associates a role with your account. AWS IoT Greengrass will use the role to access your Lambda functions and AWS IoT resources. This is necessary for deployments to succeed. The role must have at least minimum permissions in the policy ''AWSGreengrassResourceAccessRolePolicy''.
    ///
    /// Parameters:
    ///   - roleArn: The ARN of the service role you wish to associate with your account.
    ///   - logger: Logger use during operation
    @inlinable
    public func associateServiceRoleToAccount(
        roleArn: String? = nil,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> AssociateServiceRoleToAccountResponse {
        let input = AssociateServiceRoleToAccountRequest(
            roleArn: roleArn
        )
        return try await self.associateServiceRoleToAccount(input, logger: logger)
    }

    /// Creates a connector definition. You may provide the initial version of the connector definition now or use ''CreateConnectorDefinitionVersion'' at a later time.
    @Sendable
    @inlinable
    public func createConnectorDefinition(_ input: CreateConnectorDefinitionRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> CreateConnectorDefinitionResponse {
        try await self.client.execute(
            operation: "CreateConnectorDefinition", 
            path: "/greengrass/definition/connectors", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a connector definition. You may provide the initial version of the connector definition now or use ''CreateConnectorDefinitionVersion'' at a later time.
    ///
    /// Parameters:
    ///   - amznClientToken: A client token used to correlate requests and responses.
    ///   - initialVersion: Information about the initial version of the connector definition.
    ///   - name: The name of the connector definition.
    ///   - tags: Tag(s) to add to the new resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func createConnectorDefinition(
        amznClientToken: String? = nil,
        initialVersion: ConnectorDefinitionVersion? = nil,
        name: String? = nil,
        tags: [String: String]? = nil,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateConnectorDefinitionResponse {
        let input = CreateConnectorDefinitionRequest(
            amznClientToken: amznClientToken, 
            initialVersion: initialVersion, 
            name: name, 
            tags: tags
        )
        return try await self.createConnectorDefinition(input, logger: logger)
    }

    /// Creates a version of a connector definition which has already been defined.
    @Sendable
    @inlinable
    public func createConnectorDefinitionVersion(_ input: CreateConnectorDefinitionVersionRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> CreateConnectorDefinitionVersionResponse {
        try await self.client.execute(
            operation: "CreateConnectorDefinitionVersion", 
            path: "/greengrass/definition/connectors/{ConnectorDefinitionId}/versions", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a version of a connector definition which has already been defined.
    ///
    /// Parameters:
    ///   - amznClientToken: A client token used to correlate requests and responses.
    ///   - connectorDefinitionId: The ID of the connector definition.
    ///   - connectors: A list of references to connectors in this version, with their corresponding configuration settings.
    ///   - logger: Logger use during operation
    @inlinable
    public func createConnectorDefinitionVersion(
        amznClientToken: String? = nil,
        connectorDefinitionId: String,
        connectors: [Connector]? = nil,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateConnectorDefinitionVersionResponse {
        let input = CreateConnectorDefinitionVersionRequest(
            amznClientToken: amznClientToken, 
            connectorDefinitionId: connectorDefinitionId, 
            connectors: connectors
        )
        return try await self.createConnectorDefinitionVersion(input, logger: logger)
    }

    /// Creates a core definition. You may provide the initial version of the core definition now or use ''CreateCoreDefinitionVersion'' at a later time. Greengrass groups must each contain exactly one Greengrass core.
    @Sendable
    @inlinable
    public func createCoreDefinition(_ input: CreateCoreDefinitionRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> CreateCoreDefinitionResponse {
        try await self.client.execute(
            operation: "CreateCoreDefinition", 
            path: "/greengrass/definition/cores", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a core definition. You may provide the initial version of the core definition now or use ''CreateCoreDefinitionVersion'' at a later time. Greengrass groups must each contain exactly one Greengrass core.
    ///
    /// Parameters:
    ///   - amznClientToken: A client token used to correlate requests and responses.
    ///   - initialVersion: Information about the initial version of the core definition.
    ///   - name: The name of the core definition.
    ///   - tags: Tag(s) to add to the new resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func createCoreDefinition(
        amznClientToken: String? = nil,
        initialVersion: CoreDefinitionVersion? = nil,
        name: String? = nil,
        tags: [String: String]? = nil,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateCoreDefinitionResponse {
        let input = CreateCoreDefinitionRequest(
            amznClientToken: amznClientToken, 
            initialVersion: initialVersion, 
            name: name, 
            tags: tags
        )
        return try await self.createCoreDefinition(input, logger: logger)
    }

    /// Creates a version of a core definition that has already been defined. Greengrass groups must each contain exactly one Greengrass core.
    @Sendable
    @inlinable
    public func createCoreDefinitionVersion(_ input: CreateCoreDefinitionVersionRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> CreateCoreDefinitionVersionResponse {
        try await self.client.execute(
            operation: "CreateCoreDefinitionVersion", 
            path: "/greengrass/definition/cores/{CoreDefinitionId}/versions", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a version of a core definition that has already been defined. Greengrass groups must each contain exactly one Greengrass core.
    ///
    /// Parameters:
    ///   - amznClientToken: A client token used to correlate requests and responses.
    ///   - coreDefinitionId: The ID of the core definition.
    ///   - cores: A list of cores in the core definition version.
    ///   - logger: Logger use during operation
    @inlinable
    public func createCoreDefinitionVersion(
        amznClientToken: String? = nil,
        coreDefinitionId: String,
        cores: [Core]? = nil,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateCoreDefinitionVersionResponse {
        let input = CreateCoreDefinitionVersionRequest(
            amznClientToken: amznClientToken, 
            coreDefinitionId: coreDefinitionId, 
            cores: cores
        )
        return try await self.createCoreDefinitionVersion(input, logger: logger)
    }

    /// Creates a deployment. ''CreateDeployment'' requests are idempotent with respect to the ''X-Amzn-Client-Token'' token and the request parameters.
    @Sendable
    @inlinable
    public func createDeployment(_ input: CreateDeploymentRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> CreateDeploymentResponse {
        try await self.client.execute(
            operation: "CreateDeployment", 
            path: "/greengrass/groups/{GroupId}/deployments", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a deployment. ''CreateDeployment'' requests are idempotent with respect to the ''X-Amzn-Client-Token'' token and the request parameters.
    ///
    /// Parameters:
    ///   - amznClientToken: A client token used to correlate requests and responses.
    ///   - deploymentId: The ID of the deployment if you wish to redeploy a previous deployment.
    ///   - deploymentType: The type of deployment. When used for ''CreateDeployment'', only ''NewDeployment'' and ''Redeployment'' are valid.
    ///   - groupId: The ID of the Greengrass group.
    ///   - groupVersionId: The ID of the group version to be deployed.
    ///   - logger: Logger use during operation
    @inlinable
    public func createDeployment(
        amznClientToken: String? = nil,
        deploymentId: String? = nil,
        deploymentType: DeploymentType? = nil,
        groupId: String,
        groupVersionId: String? = nil,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateDeploymentResponse {
        let input = CreateDeploymentRequest(
            amznClientToken: amznClientToken, 
            deploymentId: deploymentId, 
            deploymentType: deploymentType, 
            groupId: groupId, 
            groupVersionId: groupVersionId
        )
        return try await self.createDeployment(input, logger: logger)
    }

    /// Creates a device definition. You may provide the initial version of the device definition now or use ''CreateDeviceDefinitionVersion'' at a later time.
    @Sendable
    @inlinable
    public func createDeviceDefinition(_ input: CreateDeviceDefinitionRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> CreateDeviceDefinitionResponse {
        try await self.client.execute(
            operation: "CreateDeviceDefinition", 
            path: "/greengrass/definition/devices", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a device definition. You may provide the initial version of the device definition now or use ''CreateDeviceDefinitionVersion'' at a later time.
    ///
    /// Parameters:
    ///   - amznClientToken: A client token used to correlate requests and responses.
    ///   - initialVersion: Information about the initial version of the device definition.
    ///   - name: The name of the device definition.
    ///   - tags: Tag(s) to add to the new resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func createDeviceDefinition(
        amznClientToken: String? = nil,
        initialVersion: DeviceDefinitionVersion? = nil,
        name: String? = nil,
        tags: [String: String]? = nil,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateDeviceDefinitionResponse {
        let input = CreateDeviceDefinitionRequest(
            amznClientToken: amznClientToken, 
            initialVersion: initialVersion, 
            name: name, 
            tags: tags
        )
        return try await self.createDeviceDefinition(input, logger: logger)
    }

    /// Creates a version of a device definition that has already been defined.
    @Sendable
    @inlinable
    public func createDeviceDefinitionVersion(_ input: CreateDeviceDefinitionVersionRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> CreateDeviceDefinitionVersionResponse {
        try await self.client.execute(
            operation: "CreateDeviceDefinitionVersion", 
            path: "/greengrass/definition/devices/{DeviceDefinitionId}/versions", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a version of a device definition that has already been defined.
    ///
    /// Parameters:
    ///   - amznClientToken: A client token used to correlate requests and responses.
    ///   - deviceDefinitionId: The ID of the device definition.
    ///   - devices: A list of devices in the definition version.
    ///   - logger: Logger use during operation
    @inlinable
    public func createDeviceDefinitionVersion(
        amznClientToken: String? = nil,
        deviceDefinitionId: String,
        devices: [Device]? = nil,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateDeviceDefinitionVersionResponse {
        let input = CreateDeviceDefinitionVersionRequest(
            amznClientToken: amznClientToken, 
            deviceDefinitionId: deviceDefinitionId, 
            devices: devices
        )
        return try await self.createDeviceDefinitionVersion(input, logger: logger)
    }

    /// Creates a Lambda function definition which contains a list of Lambda functions and their configurations to be used in a group. You can create an initial version of the definition by providing a list of Lambda functions and their configurations now, or use ''CreateFunctionDefinitionVersion'' later.
    @Sendable
    @inlinable
    public func createFunctionDefinition(_ input: CreateFunctionDefinitionRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> CreateFunctionDefinitionResponse {
        try await self.client.execute(
            operation: "CreateFunctionDefinition", 
            path: "/greengrass/definition/functions", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a Lambda function definition which contains a list of Lambda functions and their configurations to be used in a group. You can create an initial version of the definition by providing a list of Lambda functions and their configurations now, or use ''CreateFunctionDefinitionVersion'' later.
    ///
    /// Parameters:
    ///   - amznClientToken: A client token used to correlate requests and responses.
    ///   - initialVersion: Information about the initial version of the function definition.
    ///   - name: The name of the function definition.
    ///   - tags: Tag(s) to add to the new resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func createFunctionDefinition(
        amznClientToken: String? = nil,
        initialVersion: FunctionDefinitionVersion? = nil,
        name: String? = nil,
        tags: [String: String]? = nil,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateFunctionDefinitionResponse {
        let input = CreateFunctionDefinitionRequest(
            amznClientToken: amznClientToken, 
            initialVersion: initialVersion, 
            name: name, 
            tags: tags
        )
        return try await self.createFunctionDefinition(input, logger: logger)
    }

    /// Creates a version of a Lambda function definition that has already been defined.
    @Sendable
    @inlinable
    public func createFunctionDefinitionVersion(_ input: CreateFunctionDefinitionVersionRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> CreateFunctionDefinitionVersionResponse {
        try await self.client.execute(
            operation: "CreateFunctionDefinitionVersion", 
            path: "/greengrass/definition/functions/{FunctionDefinitionId}/versions", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a version of a Lambda function definition that has already been defined.
    ///
    /// Parameters:
    ///   - amznClientToken: A client token used to correlate requests and responses.
    ///   - defaultConfig: The default configuration that applies to all Lambda functions in this function definition version. Individual Lambda functions can override these settings.
    ///   - functionDefinitionId: The ID of the Lambda function definition.
    ///   - functions: A list of Lambda functions in this function definition version.
    ///   - logger: Logger use during operation
    @inlinable
    public func createFunctionDefinitionVersion(
        amznClientToken: String? = nil,
        defaultConfig: FunctionDefaultConfig? = nil,
        functionDefinitionId: String,
        functions: [Function]? = nil,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateFunctionDefinitionVersionResponse {
        let input = CreateFunctionDefinitionVersionRequest(
            amznClientToken: amznClientToken, 
            defaultConfig: defaultConfig, 
            functionDefinitionId: functionDefinitionId, 
            functions: functions
        )
        return try await self.createFunctionDefinitionVersion(input, logger: logger)
    }

    /// Creates a group. You may provide the initial version of the group or use ''CreateGroupVersion'' at a later time. Tip: You can use the ''gg_group_setup'' package (https://github.com/awslabs/aws-greengrass-group-setup) as a library or command-line application to create and deploy Greengrass groups.
    @Sendable
    @inlinable
    public func createGroup(_ input: CreateGroupRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> CreateGroupResponse {
        try await self.client.execute(
            operation: "CreateGroup", 
            path: "/greengrass/groups", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a group. You may provide the initial version of the group or use ''CreateGroupVersion'' at a later time. Tip: You can use the ''gg_group_setup'' package (https://github.com/awslabs/aws-greengrass-group-setup) as a library or command-line application to create and deploy Greengrass groups.
    ///
    /// Parameters:
    ///   - amznClientToken: A client token used to correlate requests and responses.
    ///   - initialVersion: Information about the initial version of the group.
    ///   - name: The name of the group.
    ///   - tags: Tag(s) to add to the new resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func createGroup(
        amznClientToken: String? = nil,
        initialVersion: GroupVersion? = nil,
        name: String? = nil,
        tags: [String: String]? = nil,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateGroupResponse {
        let input = CreateGroupRequest(
            amznClientToken: amznClientToken, 
            initialVersion: initialVersion, 
            name: name, 
            tags: tags
        )
        return try await self.createGroup(input, logger: logger)
    }

    /// Creates a CA for the group. If a CA already exists, it will rotate the existing CA.
    @Sendable
    @inlinable
    public func createGroupCertificateAuthority(_ input: CreateGroupCertificateAuthorityRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> CreateGroupCertificateAuthorityResponse {
        try await self.client.execute(
            operation: "CreateGroupCertificateAuthority", 
            path: "/greengrass/groups/{GroupId}/certificateauthorities", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a CA for the group. If a CA already exists, it will rotate the existing CA.
    ///
    /// Parameters:
    ///   - amznClientToken: A client token used to correlate requests and responses.
    ///   - groupId: The ID of the Greengrass group.
    ///   - logger: Logger use during operation
    @inlinable
    public func createGroupCertificateAuthority(
        amznClientToken: String? = nil,
        groupId: String,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateGroupCertificateAuthorityResponse {
        let input = CreateGroupCertificateAuthorityRequest(
            amznClientToken: amznClientToken, 
            groupId: groupId
        )
        return try await self.createGroupCertificateAuthority(input, logger: logger)
    }

    /// Creates a version of a group which has already been defined.
    @Sendable
    @inlinable
    public func createGroupVersion(_ input: CreateGroupVersionRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> CreateGroupVersionResponse {
        try await self.client.execute(
            operation: "CreateGroupVersion", 
            path: "/greengrass/groups/{GroupId}/versions", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a version of a group which has already been defined.
    ///
    /// Parameters:
    ///   - amznClientToken: A client token used to correlate requests and responses.
    ///   - connectorDefinitionVersionArn: The ARN of the connector definition version for this group.
    ///   - coreDefinitionVersionArn: The ARN of the core definition version for this group.
    ///   - deviceDefinitionVersionArn: The ARN of the device definition version for this group.
    ///   - functionDefinitionVersionArn: The ARN of the function definition version for this group.
    ///   - groupId: The ID of the Greengrass group.
    ///   - loggerDefinitionVersionArn: The ARN of the logger definition version for this group.
    ///   - resourceDefinitionVersionArn: The ARN of the resource definition version for this group.
    ///   - subscriptionDefinitionVersionArn: The ARN of the subscription definition version for this group.
    ///   - logger: Logger use during operation
    @inlinable
    public func createGroupVersion(
        amznClientToken: String? = nil,
        connectorDefinitionVersionArn: String? = nil,
        coreDefinitionVersionArn: String? = nil,
        deviceDefinitionVersionArn: String? = nil,
        functionDefinitionVersionArn: String? = nil,
        groupId: String,
        loggerDefinitionVersionArn: String? = nil,
        resourceDefinitionVersionArn: String? = nil,
        subscriptionDefinitionVersionArn: String? = nil,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateGroupVersionResponse {
        let input = CreateGroupVersionRequest(
            amznClientToken: amznClientToken, 
            connectorDefinitionVersionArn: connectorDefinitionVersionArn, 
            coreDefinitionVersionArn: coreDefinitionVersionArn, 
            deviceDefinitionVersionArn: deviceDefinitionVersionArn, 
            functionDefinitionVersionArn: functionDefinitionVersionArn, 
            groupId: groupId, 
            loggerDefinitionVersionArn: loggerDefinitionVersionArn, 
            resourceDefinitionVersionArn: resourceDefinitionVersionArn, 
            subscriptionDefinitionVersionArn: subscriptionDefinitionVersionArn
        )
        return try await self.createGroupVersion(input, logger: logger)
    }

    /// Creates a logger definition. You may provide the initial version of the logger definition now or use ''CreateLoggerDefinitionVersion'' at a later time.
    @Sendable
    @inlinable
    public func createLoggerDefinition(_ input: CreateLoggerDefinitionRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> CreateLoggerDefinitionResponse {
        try await self.client.execute(
            operation: "CreateLoggerDefinition", 
            path: "/greengrass/definition/loggers", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a logger definition. You may provide the initial version of the logger definition now or use ''CreateLoggerDefinitionVersion'' at a later time.
    ///
    /// Parameters:
    ///   - amznClientToken: A client token used to correlate requests and responses.
    ///   - initialVersion: Information about the initial version of the logger definition.
    ///   - name: The name of the logger definition.
    ///   - tags: Tag(s) to add to the new resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func createLoggerDefinition(
        amznClientToken: String? = nil,
        initialVersion: LoggerDefinitionVersion? = nil,
        name: String? = nil,
        tags: [String: String]? = nil,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateLoggerDefinitionResponse {
        let input = CreateLoggerDefinitionRequest(
            amznClientToken: amznClientToken, 
            initialVersion: initialVersion, 
            name: name, 
            tags: tags
        )
        return try await self.createLoggerDefinition(input, logger: logger)
    }

    /// Creates a version of a logger definition that has already been defined.
    @Sendable
    @inlinable
    public func createLoggerDefinitionVersion(_ input: CreateLoggerDefinitionVersionRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> CreateLoggerDefinitionVersionResponse {
        try await self.client.execute(
            operation: "CreateLoggerDefinitionVersion", 
            path: "/greengrass/definition/loggers/{LoggerDefinitionId}/versions", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a version of a logger definition that has already been defined.
    ///
    /// Parameters:
    ///   - amznClientToken: A client token used to correlate requests and responses.
    ///   - loggerDefinitionId: The ID of the logger definition.
    ///   - loggers: A list of loggers.
    ///   - logger: Logger use during operation
    @inlinable
    public func createLoggerDefinitionVersion(
        amznClientToken: String? = nil,
        loggerDefinitionId: String,
        loggers: [Logger]? = nil,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateLoggerDefinitionVersionResponse {
        let input = CreateLoggerDefinitionVersionRequest(
            amznClientToken: amznClientToken, 
            loggerDefinitionId: loggerDefinitionId, 
            loggers: loggers
        )
        return try await self.createLoggerDefinitionVersion(input, logger: logger)
    }

    /// Creates a resource definition which contains a list of resources to be used in a group. You can create an initial version of the definition by providing a list of resources now, or use ''CreateResourceDefinitionVersion'' later.
    @Sendable
    @inlinable
    public func createResourceDefinition(_ input: CreateResourceDefinitionRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> CreateResourceDefinitionResponse {
        try await self.client.execute(
            operation: "CreateResourceDefinition", 
            path: "/greengrass/definition/resources", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a resource definition which contains a list of resources to be used in a group. You can create an initial version of the definition by providing a list of resources now, or use ''CreateResourceDefinitionVersion'' later.
    ///
    /// Parameters:
    ///   - amznClientToken: A client token used to correlate requests and responses.
    ///   - initialVersion: Information about the initial version of the resource definition.
    ///   - name: The name of the resource definition.
    ///   - tags: Tag(s) to add to the new resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func createResourceDefinition(
        amznClientToken: String? = nil,
        initialVersion: ResourceDefinitionVersion? = nil,
        name: String? = nil,
        tags: [String: String]? = nil,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateResourceDefinitionResponse {
        let input = CreateResourceDefinitionRequest(
            amznClientToken: amznClientToken, 
            initialVersion: initialVersion, 
            name: name, 
            tags: tags
        )
        return try await self.createResourceDefinition(input, logger: logger)
    }

    /// Creates a version of a resource definition that has already been defined.
    @Sendable
    @inlinable
    public func createResourceDefinitionVersion(_ input: CreateResourceDefinitionVersionRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> CreateResourceDefinitionVersionResponse {
        try await self.client.execute(
            operation: "CreateResourceDefinitionVersion", 
            path: "/greengrass/definition/resources/{ResourceDefinitionId}/versions", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a version of a resource definition that has already been defined.
    ///
    /// Parameters:
    ///   - amznClientToken: A client token used to correlate requests and responses.
    ///   - resourceDefinitionId: The ID of the resource definition.
    ///   - resources: A list of resources.
    ///   - logger: Logger use during operation
    @inlinable
    public func createResourceDefinitionVersion(
        amznClientToken: String? = nil,
        resourceDefinitionId: String,
        resources: [Resource]? = nil,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateResourceDefinitionVersionResponse {
        let input = CreateResourceDefinitionVersionRequest(
            amznClientToken: amznClientToken, 
            resourceDefinitionId: resourceDefinitionId, 
            resources: resources
        )
        return try await self.createResourceDefinitionVersion(input, logger: logger)
    }

    /// Creates a software update for a core or group of cores (specified as an IoT thing group.) Use this to update the OTA Agent as well as the Greengrass core software. It makes use of the IoT Jobs feature which provides additional commands to manage a Greengrass core software update job.
    @Sendable
    @inlinable
    public func createSoftwareUpdateJob(_ input: CreateSoftwareUpdateJobRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> CreateSoftwareUpdateJobResponse {
        try await self.client.execute(
            operation: "CreateSoftwareUpdateJob", 
            path: "/greengrass/updates", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a software update for a core or group of cores (specified as an IoT thing group.) Use this to update the OTA Agent as well as the Greengrass core software. It makes use of the IoT Jobs feature which provides additional commands to manage a Greengrass core software update job.
    ///
    /// Parameters:
    ///   - amznClientToken: A client token used to correlate requests and responses.
    ///   - s3UrlSignerRole: 
    ///   - softwareToUpdate: 
    ///   - updateAgentLogLevel: 
    ///   - updateTargets: 
    ///   - updateTargetsArchitecture: 
    ///   - updateTargetsOperatingSystem: 
    ///   - logger: Logger use during operation
    @inlinable
    public func createSoftwareUpdateJob(
        amznClientToken: String? = nil,
        s3UrlSignerRole: String? = nil,
        softwareToUpdate: SoftwareToUpdate? = nil,
        updateAgentLogLevel: UpdateAgentLogLevel? = nil,
        updateTargets: [String]? = nil,
        updateTargetsArchitecture: UpdateTargetsArchitecture? = nil,
        updateTargetsOperatingSystem: UpdateTargetsOperatingSystem? = nil,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateSoftwareUpdateJobResponse {
        let input = CreateSoftwareUpdateJobRequest(
            amznClientToken: amznClientToken, 
            s3UrlSignerRole: s3UrlSignerRole, 
            softwareToUpdate: softwareToUpdate, 
            updateAgentLogLevel: updateAgentLogLevel, 
            updateTargets: updateTargets, 
            updateTargetsArchitecture: updateTargetsArchitecture, 
            updateTargetsOperatingSystem: updateTargetsOperatingSystem
        )
        return try await self.createSoftwareUpdateJob(input, logger: logger)
    }

    /// Creates a subscription definition. You may provide the initial version of the subscription definition now or use ''CreateSubscriptionDefinitionVersion'' at a later time.
    @Sendable
    @inlinable
    public func createSubscriptionDefinition(_ input: CreateSubscriptionDefinitionRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> CreateSubscriptionDefinitionResponse {
        try await self.client.execute(
            operation: "CreateSubscriptionDefinition", 
            path: "/greengrass/definition/subscriptions", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a subscription definition. You may provide the initial version of the subscription definition now or use ''CreateSubscriptionDefinitionVersion'' at a later time.
    ///
    /// Parameters:
    ///   - amznClientToken: A client token used to correlate requests and responses.
    ///   - initialVersion: Information about the initial version of the subscription definition.
    ///   - name: The name of the subscription definition.
    ///   - tags: Tag(s) to add to the new resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func createSubscriptionDefinition(
        amznClientToken: String? = nil,
        initialVersion: SubscriptionDefinitionVersion? = nil,
        name: String? = nil,
        tags: [String: String]? = nil,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateSubscriptionDefinitionResponse {
        let input = CreateSubscriptionDefinitionRequest(
            amznClientToken: amznClientToken, 
            initialVersion: initialVersion, 
            name: name, 
            tags: tags
        )
        return try await self.createSubscriptionDefinition(input, logger: logger)
    }

    /// Creates a version of a subscription definition which has already been defined.
    @Sendable
    @inlinable
    public func createSubscriptionDefinitionVersion(_ input: CreateSubscriptionDefinitionVersionRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> CreateSubscriptionDefinitionVersionResponse {
        try await self.client.execute(
            operation: "CreateSubscriptionDefinitionVersion", 
            path: "/greengrass/definition/subscriptions/{SubscriptionDefinitionId}/versions", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a version of a subscription definition which has already been defined.
    ///
    /// Parameters:
    ///   - amznClientToken: A client token used to correlate requests and responses.
    ///   - subscriptionDefinitionId: The ID of the subscription definition.
    ///   - subscriptions: A list of subscriptions.
    ///   - logger: Logger use during operation
    @inlinable
    public func createSubscriptionDefinitionVersion(
        amznClientToken: String? = nil,
        subscriptionDefinitionId: String,
        subscriptions: [Subscription]? = nil,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateSubscriptionDefinitionVersionResponse {
        let input = CreateSubscriptionDefinitionVersionRequest(
            amznClientToken: amznClientToken, 
            subscriptionDefinitionId: subscriptionDefinitionId, 
            subscriptions: subscriptions
        )
        return try await self.createSubscriptionDefinitionVersion(input, logger: logger)
    }

    /// Deletes a connector definition.
    @Sendable
    @inlinable
    public func deleteConnectorDefinition(_ input: DeleteConnectorDefinitionRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> DeleteConnectorDefinitionResponse {
        try await self.client.execute(
            operation: "DeleteConnectorDefinition", 
            path: "/greengrass/definition/connectors/{ConnectorDefinitionId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a connector definition.
    ///
    /// Parameters:
    ///   - connectorDefinitionId: The ID of the connector definition.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteConnectorDefinition(
        connectorDefinitionId: String,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteConnectorDefinitionResponse {
        let input = DeleteConnectorDefinitionRequest(
            connectorDefinitionId: connectorDefinitionId
        )
        return try await self.deleteConnectorDefinition(input, logger: logger)
    }

    /// Deletes a core definition.
    @Sendable
    @inlinable
    public func deleteCoreDefinition(_ input: DeleteCoreDefinitionRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> DeleteCoreDefinitionResponse {
        try await self.client.execute(
            operation: "DeleteCoreDefinition", 
            path: "/greengrass/definition/cores/{CoreDefinitionId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a core definition.
    ///
    /// Parameters:
    ///   - coreDefinitionId: The ID of the core definition.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteCoreDefinition(
        coreDefinitionId: String,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteCoreDefinitionResponse {
        let input = DeleteCoreDefinitionRequest(
            coreDefinitionId: coreDefinitionId
        )
        return try await self.deleteCoreDefinition(input, logger: logger)
    }

    /// Deletes a device definition.
    @Sendable
    @inlinable
    public func deleteDeviceDefinition(_ input: DeleteDeviceDefinitionRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> DeleteDeviceDefinitionResponse {
        try await self.client.execute(
            operation: "DeleteDeviceDefinition", 
            path: "/greengrass/definition/devices/{DeviceDefinitionId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a device definition.
    ///
    /// Parameters:
    ///   - deviceDefinitionId: The ID of the device definition.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteDeviceDefinition(
        deviceDefinitionId: String,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteDeviceDefinitionResponse {
        let input = DeleteDeviceDefinitionRequest(
            deviceDefinitionId: deviceDefinitionId
        )
        return try await self.deleteDeviceDefinition(input, logger: logger)
    }

    /// Deletes a Lambda function definition.
    @Sendable
    @inlinable
    public func deleteFunctionDefinition(_ input: DeleteFunctionDefinitionRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> DeleteFunctionDefinitionResponse {
        try await self.client.execute(
            operation: "DeleteFunctionDefinition", 
            path: "/greengrass/definition/functions/{FunctionDefinitionId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a Lambda function definition.
    ///
    /// Parameters:
    ///   - functionDefinitionId: The ID of the Lambda function definition.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteFunctionDefinition(
        functionDefinitionId: String,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteFunctionDefinitionResponse {
        let input = DeleteFunctionDefinitionRequest(
            functionDefinitionId: functionDefinitionId
        )
        return try await self.deleteFunctionDefinition(input, logger: logger)
    }

    /// Deletes a group.
    @Sendable
    @inlinable
    public func deleteGroup(_ input: DeleteGroupRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> DeleteGroupResponse {
        try await self.client.execute(
            operation: "DeleteGroup", 
            path: "/greengrass/groups/{GroupId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a group.
    ///
    /// Parameters:
    ///   - groupId: The ID of the Greengrass group.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteGroup(
        groupId: String,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteGroupResponse {
        let input = DeleteGroupRequest(
            groupId: groupId
        )
        return try await self.deleteGroup(input, logger: logger)
    }

    /// Deletes a logger definition.
    @Sendable
    @inlinable
    public func deleteLoggerDefinition(_ input: DeleteLoggerDefinitionRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> DeleteLoggerDefinitionResponse {
        try await self.client.execute(
            operation: "DeleteLoggerDefinition", 
            path: "/greengrass/definition/loggers/{LoggerDefinitionId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a logger definition.
    ///
    /// Parameters:
    ///   - loggerDefinitionId: The ID of the logger definition.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteLoggerDefinition(
        loggerDefinitionId: String,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteLoggerDefinitionResponse {
        let input = DeleteLoggerDefinitionRequest(
            loggerDefinitionId: loggerDefinitionId
        )
        return try await self.deleteLoggerDefinition(input, logger: logger)
    }

    /// Deletes a resource definition.
    @Sendable
    @inlinable
    public func deleteResourceDefinition(_ input: DeleteResourceDefinitionRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> DeleteResourceDefinitionResponse {
        try await self.client.execute(
            operation: "DeleteResourceDefinition", 
            path: "/greengrass/definition/resources/{ResourceDefinitionId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a resource definition.
    ///
    /// Parameters:
    ///   - resourceDefinitionId: The ID of the resource definition.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteResourceDefinition(
        resourceDefinitionId: String,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteResourceDefinitionResponse {
        let input = DeleteResourceDefinitionRequest(
            resourceDefinitionId: resourceDefinitionId
        )
        return try await self.deleteResourceDefinition(input, logger: logger)
    }

    /// Deletes a subscription definition.
    @Sendable
    @inlinable
    public func deleteSubscriptionDefinition(_ input: DeleteSubscriptionDefinitionRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> DeleteSubscriptionDefinitionResponse {
        try await self.client.execute(
            operation: "DeleteSubscriptionDefinition", 
            path: "/greengrass/definition/subscriptions/{SubscriptionDefinitionId}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a subscription definition.
    ///
    /// Parameters:
    ///   - subscriptionDefinitionId: The ID of the subscription definition.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteSubscriptionDefinition(
        subscriptionDefinitionId: String,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteSubscriptionDefinitionResponse {
        let input = DeleteSubscriptionDefinitionRequest(
            subscriptionDefinitionId: subscriptionDefinitionId
        )
        return try await self.deleteSubscriptionDefinition(input, logger: logger)
    }

    /// Disassociates the role from a group.
    @Sendable
    @inlinable
    public func disassociateRoleFromGroup(_ input: DisassociateRoleFromGroupRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> DisassociateRoleFromGroupResponse {
        try await self.client.execute(
            operation: "DisassociateRoleFromGroup", 
            path: "/greengrass/groups/{GroupId}/role", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Disassociates the role from a group.
    ///
    /// Parameters:
    ///   - groupId: The ID of the Greengrass group.
    ///   - logger: Logger use during operation
    @inlinable
    public func disassociateRoleFromGroup(
        groupId: String,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> DisassociateRoleFromGroupResponse {
        let input = DisassociateRoleFromGroupRequest(
            groupId: groupId
        )
        return try await self.disassociateRoleFromGroup(input, logger: logger)
    }

    /// Disassociates the service role from your account. Without a service role, deployments will not work.
    @Sendable
    @inlinable
    public func disassociateServiceRoleFromAccount(_ input: DisassociateServiceRoleFromAccountRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> DisassociateServiceRoleFromAccountResponse {
        try await self.client.execute(
            operation: "DisassociateServiceRoleFromAccount", 
            path: "/greengrass/servicerole", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Disassociates the service role from your account. Without a service role, deployments will not work.
    ///
    /// Parameters:
    ///   - logger: Logger use during operation
    @inlinable
    public func disassociateServiceRoleFromAccount(
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> DisassociateServiceRoleFromAccountResponse {
        let input = DisassociateServiceRoleFromAccountRequest(
        )
        return try await self.disassociateServiceRoleFromAccount(input, logger: logger)
    }

    /// Retrieves the role associated with a particular group.
    @Sendable
    @inlinable
    public func getAssociatedRole(_ input: GetAssociatedRoleRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> GetAssociatedRoleResponse {
        try await self.client.execute(
            operation: "GetAssociatedRole", 
            path: "/greengrass/groups/{GroupId}/role", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves the role associated with a particular group.
    ///
    /// Parameters:
    ///   - groupId: The ID of the Greengrass group.
    ///   - logger: Logger use during operation
    @inlinable
    public func getAssociatedRole(
        groupId: String,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> GetAssociatedRoleResponse {
        let input = GetAssociatedRoleRequest(
            groupId: groupId
        )
        return try await self.getAssociatedRole(input, logger: logger)
    }

    /// Returns the status of a bulk deployment.
    @Sendable
    @inlinable
    public func getBulkDeploymentStatus(_ input: GetBulkDeploymentStatusRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> GetBulkDeploymentStatusResponse {
        try await self.client.execute(
            operation: "GetBulkDeploymentStatus", 
            path: "/greengrass/bulk/deployments/{BulkDeploymentId}/status", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns the status of a bulk deployment.
    ///
    /// Parameters:
    ///   - bulkDeploymentId: The ID of the bulk deployment.
    ///   - logger: Logger use during operation
    @inlinable
    public func getBulkDeploymentStatus(
        bulkDeploymentId: String,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> GetBulkDeploymentStatusResponse {
        let input = GetBulkDeploymentStatusRequest(
            bulkDeploymentId: bulkDeploymentId
        )
        return try await self.getBulkDeploymentStatus(input, logger: logger)
    }

    /// Retrieves the connectivity information for a core.
    @Sendable
    @inlinable
    public func getConnectivityInfo(_ input: GetConnectivityInfoRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> GetConnectivityInfoResponse {
        try await self.client.execute(
            operation: "GetConnectivityInfo", 
            path: "/greengrass/things/{ThingName}/connectivityInfo", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves the connectivity information for a core.
    ///
    /// Parameters:
    ///   - thingName: The thing name.
    ///   - logger: Logger use during operation
    @inlinable
    public func getConnectivityInfo(
        thingName: String,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> GetConnectivityInfoResponse {
        let input = GetConnectivityInfoRequest(
            thingName: thingName
        )
        return try await self.getConnectivityInfo(input, logger: logger)
    }

    /// Retrieves information about a connector definition.
    @Sendable
    @inlinable
    public func getConnectorDefinition(_ input: GetConnectorDefinitionRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> GetConnectorDefinitionResponse {
        try await self.client.execute(
            operation: "GetConnectorDefinition", 
            path: "/greengrass/definition/connectors/{ConnectorDefinitionId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about a connector definition.
    ///
    /// Parameters:
    ///   - connectorDefinitionId: The ID of the connector definition.
    ///   - logger: Logger use during operation
    @inlinable
    public func getConnectorDefinition(
        connectorDefinitionId: String,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> GetConnectorDefinitionResponse {
        let input = GetConnectorDefinitionRequest(
            connectorDefinitionId: connectorDefinitionId
        )
        return try await self.getConnectorDefinition(input, logger: logger)
    }

    /// Retrieves information about a connector definition version, including the connectors that the version contains. Connectors are prebuilt modules that interact with local infrastructure, device protocols, AWS, and other cloud services.
    @Sendable
    @inlinable
    public func getConnectorDefinitionVersion(_ input: GetConnectorDefinitionVersionRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> GetConnectorDefinitionVersionResponse {
        try await self.client.execute(
            operation: "GetConnectorDefinitionVersion", 
            path: "/greengrass/definition/connectors/{ConnectorDefinitionId}/versions/{ConnectorDefinitionVersionId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about a connector definition version, including the connectors that the version contains. Connectors are prebuilt modules that interact with local infrastructure, device protocols, AWS, and other cloud services.
    ///
    /// Parameters:
    ///   - connectorDefinitionId: The ID of the connector definition.
    ///   - connectorDefinitionVersionId: The ID of the connector definition version. This value maps to the ''Version'' property of the corresponding ''VersionInformation'' object, which is returned by ''ListConnectorDefinitionVersions'' requests. If the version is the last one that was associated with a connector definition, the value also maps to the ''LatestVersion'' property of the corresponding ''DefinitionInformation'' object.
    ///   - nextToken: The token for the next set of results, or ''null'' if there are no additional results.
    ///   - logger: Logger use during operation
    @inlinable
    public func getConnectorDefinitionVersion(
        connectorDefinitionId: String,
        connectorDefinitionVersionId: String,
        nextToken: String? = nil,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> GetConnectorDefinitionVersionResponse {
        let input = GetConnectorDefinitionVersionRequest(
            connectorDefinitionId: connectorDefinitionId, 
            connectorDefinitionVersionId: connectorDefinitionVersionId, 
            nextToken: nextToken
        )
        return try await self.getConnectorDefinitionVersion(input, logger: logger)
    }

    /// Retrieves information about a core definition version.
    @Sendable
    @inlinable
    public func getCoreDefinition(_ input: GetCoreDefinitionRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> GetCoreDefinitionResponse {
        try await self.client.execute(
            operation: "GetCoreDefinition", 
            path: "/greengrass/definition/cores/{CoreDefinitionId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about a core definition version.
    ///
    /// Parameters:
    ///   - coreDefinitionId: The ID of the core definition.
    ///   - logger: Logger use during operation
    @inlinable
    public func getCoreDefinition(
        coreDefinitionId: String,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> GetCoreDefinitionResponse {
        let input = GetCoreDefinitionRequest(
            coreDefinitionId: coreDefinitionId
        )
        return try await self.getCoreDefinition(input, logger: logger)
    }

    /// Retrieves information about a core definition version.
    @Sendable
    @inlinable
    public func getCoreDefinitionVersion(_ input: GetCoreDefinitionVersionRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> GetCoreDefinitionVersionResponse {
        try await self.client.execute(
            operation: "GetCoreDefinitionVersion", 
            path: "/greengrass/definition/cores/{CoreDefinitionId}/versions/{CoreDefinitionVersionId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about a core definition version.
    ///
    /// Parameters:
    ///   - coreDefinitionId: The ID of the core definition.
    ///   - coreDefinitionVersionId: The ID of the core definition version. This value maps to the ''Version'' property of the corresponding ''VersionInformation'' object, which is returned by ''ListCoreDefinitionVersions'' requests. If the version is the last one that was associated with a core definition, the value also maps to the ''LatestVersion'' property of the corresponding ''DefinitionInformation'' object.
    ///   - logger: Logger use during operation
    @inlinable
    public func getCoreDefinitionVersion(
        coreDefinitionId: String,
        coreDefinitionVersionId: String,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> GetCoreDefinitionVersionResponse {
        let input = GetCoreDefinitionVersionRequest(
            coreDefinitionId: coreDefinitionId, 
            coreDefinitionVersionId: coreDefinitionVersionId
        )
        return try await self.getCoreDefinitionVersion(input, logger: logger)
    }

    /// Returns the status of a deployment.
    @Sendable
    @inlinable
    public func getDeploymentStatus(_ input: GetDeploymentStatusRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> GetDeploymentStatusResponse {
        try await self.client.execute(
            operation: "GetDeploymentStatus", 
            path: "/greengrass/groups/{GroupId}/deployments/{DeploymentId}/status", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns the status of a deployment.
    ///
    /// Parameters:
    ///   - deploymentId: The ID of the deployment.
    ///   - groupId: The ID of the Greengrass group.
    ///   - logger: Logger use during operation
    @inlinable
    public func getDeploymentStatus(
        deploymentId: String,
        groupId: String,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> GetDeploymentStatusResponse {
        let input = GetDeploymentStatusRequest(
            deploymentId: deploymentId, 
            groupId: groupId
        )
        return try await self.getDeploymentStatus(input, logger: logger)
    }

    /// Retrieves information about a device definition.
    @Sendable
    @inlinable
    public func getDeviceDefinition(_ input: GetDeviceDefinitionRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> GetDeviceDefinitionResponse {
        try await self.client.execute(
            operation: "GetDeviceDefinition", 
            path: "/greengrass/definition/devices/{DeviceDefinitionId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about a device definition.
    ///
    /// Parameters:
    ///   - deviceDefinitionId: The ID of the device definition.
    ///   - logger: Logger use during operation
    @inlinable
    public func getDeviceDefinition(
        deviceDefinitionId: String,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> GetDeviceDefinitionResponse {
        let input = GetDeviceDefinitionRequest(
            deviceDefinitionId: deviceDefinitionId
        )
        return try await self.getDeviceDefinition(input, logger: logger)
    }

    /// Retrieves information about a device definition version.
    @Sendable
    @inlinable
    public func getDeviceDefinitionVersion(_ input: GetDeviceDefinitionVersionRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> GetDeviceDefinitionVersionResponse {
        try await self.client.execute(
            operation: "GetDeviceDefinitionVersion", 
            path: "/greengrass/definition/devices/{DeviceDefinitionId}/versions/{DeviceDefinitionVersionId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about a device definition version.
    ///
    /// Parameters:
    ///   - deviceDefinitionId: The ID of the device definition.
    ///   - deviceDefinitionVersionId: The ID of the device definition version. This value maps to the ''Version'' property of the corresponding ''VersionInformation'' object, which is returned by ''ListDeviceDefinitionVersions'' requests. If the version is the last one that was associated with a device definition, the value also maps to the ''LatestVersion'' property of the corresponding ''DefinitionInformation'' object.
    ///   - nextToken: The token for the next set of results, or ''null'' if there are no additional results.
    ///   - logger: Logger use during operation
    @inlinable
    public func getDeviceDefinitionVersion(
        deviceDefinitionId: String,
        deviceDefinitionVersionId: String,
        nextToken: String? = nil,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> GetDeviceDefinitionVersionResponse {
        let input = GetDeviceDefinitionVersionRequest(
            deviceDefinitionId: deviceDefinitionId, 
            deviceDefinitionVersionId: deviceDefinitionVersionId, 
            nextToken: nextToken
        )
        return try await self.getDeviceDefinitionVersion(input, logger: logger)
    }

    /// Retrieves information about a Lambda function definition, including its creation time and latest version.
    @Sendable
    @inlinable
    public func getFunctionDefinition(_ input: GetFunctionDefinitionRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> GetFunctionDefinitionResponse {
        try await self.client.execute(
            operation: "GetFunctionDefinition", 
            path: "/greengrass/definition/functions/{FunctionDefinitionId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about a Lambda function definition, including its creation time and latest version.
    ///
    /// Parameters:
    ///   - functionDefinitionId: The ID of the Lambda function definition.
    ///   - logger: Logger use during operation
    @inlinable
    public func getFunctionDefinition(
        functionDefinitionId: String,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> GetFunctionDefinitionResponse {
        let input = GetFunctionDefinitionRequest(
            functionDefinitionId: functionDefinitionId
        )
        return try await self.getFunctionDefinition(input, logger: logger)
    }

    /// Retrieves information about a Lambda function definition version, including which Lambda functions are included in the version and their configurations.
    @Sendable
    @inlinable
    public func getFunctionDefinitionVersion(_ input: GetFunctionDefinitionVersionRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> GetFunctionDefinitionVersionResponse {
        try await self.client.execute(
            operation: "GetFunctionDefinitionVersion", 
            path: "/greengrass/definition/functions/{FunctionDefinitionId}/versions/{FunctionDefinitionVersionId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about a Lambda function definition version, including which Lambda functions are included in the version and their configurations.
    ///
    /// Parameters:
    ///   - functionDefinitionId: The ID of the Lambda function definition.
    ///   - functionDefinitionVersionId: The ID of the function definition version. This value maps to the ''Version'' property of the corresponding ''VersionInformation'' object, which is returned by ''ListFunctionDefinitionVersions'' requests. If the version is the last one that was associated with a function definition, the value also maps to the ''LatestVersion'' property of the corresponding ''DefinitionInformation'' object.
    ///   - nextToken: The token for the next set of results, or ''null'' if there are no additional results.
    ///   - logger: Logger use during operation
    @inlinable
    public func getFunctionDefinitionVersion(
        functionDefinitionId: String,
        functionDefinitionVersionId: String,
        nextToken: String? = nil,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> GetFunctionDefinitionVersionResponse {
        let input = GetFunctionDefinitionVersionRequest(
            functionDefinitionId: functionDefinitionId, 
            functionDefinitionVersionId: functionDefinitionVersionId, 
            nextToken: nextToken
        )
        return try await self.getFunctionDefinitionVersion(input, logger: logger)
    }

    /// Retrieves information about a group.
    @Sendable
    @inlinable
    public func getGroup(_ input: GetGroupRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> GetGroupResponse {
        try await self.client.execute(
            operation: "GetGroup", 
            path: "/greengrass/groups/{GroupId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about a group.
    ///
    /// Parameters:
    ///   - groupId: The ID of the Greengrass group.
    ///   - logger: Logger use during operation
    @inlinable
    public func getGroup(
        groupId: String,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> GetGroupResponse {
        let input = GetGroupRequest(
            groupId: groupId
        )
        return try await self.getGroup(input, logger: logger)
    }

    /// Retreives the CA associated with a group. Returns the public key of the CA.
    @Sendable
    @inlinable
    public func getGroupCertificateAuthority(_ input: GetGroupCertificateAuthorityRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> GetGroupCertificateAuthorityResponse {
        try await self.client.execute(
            operation: "GetGroupCertificateAuthority", 
            path: "/greengrass/groups/{GroupId}/certificateauthorities/{CertificateAuthorityId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retreives the CA associated with a group. Returns the public key of the CA.
    ///
    /// Parameters:
    ///   - certificateAuthorityId: The ID of the certificate authority.
    ///   - groupId: The ID of the Greengrass group.
    ///   - logger: Logger use during operation
    @inlinable
    public func getGroupCertificateAuthority(
        certificateAuthorityId: String,
        groupId: String,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> GetGroupCertificateAuthorityResponse {
        let input = GetGroupCertificateAuthorityRequest(
            certificateAuthorityId: certificateAuthorityId, 
            groupId: groupId
        )
        return try await self.getGroupCertificateAuthority(input, logger: logger)
    }

    /// Retrieves the current configuration for the CA used by the group.
    @Sendable
    @inlinable
    public func getGroupCertificateConfiguration(_ input: GetGroupCertificateConfigurationRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> GetGroupCertificateConfigurationResponse {
        try await self.client.execute(
            operation: "GetGroupCertificateConfiguration", 
            path: "/greengrass/groups/{GroupId}/certificateauthorities/configuration/expiry", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves the current configuration for the CA used by the group.
    ///
    /// Parameters:
    ///   - groupId: The ID of the Greengrass group.
    ///   - logger: Logger use during operation
    @inlinable
    public func getGroupCertificateConfiguration(
        groupId: String,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> GetGroupCertificateConfigurationResponse {
        let input = GetGroupCertificateConfigurationRequest(
            groupId: groupId
        )
        return try await self.getGroupCertificateConfiguration(input, logger: logger)
    }

    /// Retrieves information about a group version.
    @Sendable
    @inlinable
    public func getGroupVersion(_ input: GetGroupVersionRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> GetGroupVersionResponse {
        try await self.client.execute(
            operation: "GetGroupVersion", 
            path: "/greengrass/groups/{GroupId}/versions/{GroupVersionId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about a group version.
    ///
    /// Parameters:
    ///   - groupId: The ID of the Greengrass group.
    ///   - groupVersionId: The ID of the group version. This value maps to the ''Version'' property of the corresponding ''VersionInformation'' object, which is returned by ''ListGroupVersions'' requests. If the version is the last one that was associated with a group, the value also maps to the ''LatestVersion'' property of the corresponding ''GroupInformation'' object.
    ///   - logger: Logger use during operation
    @inlinable
    public func getGroupVersion(
        groupId: String,
        groupVersionId: String,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> GetGroupVersionResponse {
        let input = GetGroupVersionRequest(
            groupId: groupId, 
            groupVersionId: groupVersionId
        )
        return try await self.getGroupVersion(input, logger: logger)
    }

    /// Retrieves information about a logger definition.
    @Sendable
    @inlinable
    public func getLoggerDefinition(_ input: GetLoggerDefinitionRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> GetLoggerDefinitionResponse {
        try await self.client.execute(
            operation: "GetLoggerDefinition", 
            path: "/greengrass/definition/loggers/{LoggerDefinitionId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about a logger definition.
    ///
    /// Parameters:
    ///   - loggerDefinitionId: The ID of the logger definition.
    ///   - logger: Logger use during operation
    @inlinable
    public func getLoggerDefinition(
        loggerDefinitionId: String,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> GetLoggerDefinitionResponse {
        let input = GetLoggerDefinitionRequest(
            loggerDefinitionId: loggerDefinitionId
        )
        return try await self.getLoggerDefinition(input, logger: logger)
    }

    /// Retrieves information about a logger definition version.
    @Sendable
    @inlinable
    public func getLoggerDefinitionVersion(_ input: GetLoggerDefinitionVersionRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> GetLoggerDefinitionVersionResponse {
        try await self.client.execute(
            operation: "GetLoggerDefinitionVersion", 
            path: "/greengrass/definition/loggers/{LoggerDefinitionId}/versions/{LoggerDefinitionVersionId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about a logger definition version.
    ///
    /// Parameters:
    ///   - loggerDefinitionId: The ID of the logger definition.
    ///   - loggerDefinitionVersionId: The ID of the logger definition version. This value maps to the ''Version'' property of the corresponding ''VersionInformation'' object, which is returned by ''ListLoggerDefinitionVersions'' requests. If the version is the last one that was associated with a logger definition, the value also maps to the ''LatestVersion'' property of the corresponding ''DefinitionInformation'' object.
    ///   - nextToken: The token for the next set of results, or ''null'' if there are no additional results.
    ///   - logger: Logger use during operation
    @inlinable
    public func getLoggerDefinitionVersion(
        loggerDefinitionId: String,
        loggerDefinitionVersionId: String,
        nextToken: String? = nil,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> GetLoggerDefinitionVersionResponse {
        let input = GetLoggerDefinitionVersionRequest(
            loggerDefinitionId: loggerDefinitionId, 
            loggerDefinitionVersionId: loggerDefinitionVersionId, 
            nextToken: nextToken
        )
        return try await self.getLoggerDefinitionVersion(input, logger: logger)
    }

    /// Retrieves information about a resource definition, including its creation time and latest version.
    @Sendable
    @inlinable
    public func getResourceDefinition(_ input: GetResourceDefinitionRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> GetResourceDefinitionResponse {
        try await self.client.execute(
            operation: "GetResourceDefinition", 
            path: "/greengrass/definition/resources/{ResourceDefinitionId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about a resource definition, including its creation time and latest version.
    ///
    /// Parameters:
    ///   - resourceDefinitionId: The ID of the resource definition.
    ///   - logger: Logger use during operation
    @inlinable
    public func getResourceDefinition(
        resourceDefinitionId: String,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> GetResourceDefinitionResponse {
        let input = GetResourceDefinitionRequest(
            resourceDefinitionId: resourceDefinitionId
        )
        return try await self.getResourceDefinition(input, logger: logger)
    }

    /// Retrieves information about a resource definition version, including which resources are included in the version.
    @Sendable
    @inlinable
    public func getResourceDefinitionVersion(_ input: GetResourceDefinitionVersionRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> GetResourceDefinitionVersionResponse {
        try await self.client.execute(
            operation: "GetResourceDefinitionVersion", 
            path: "/greengrass/definition/resources/{ResourceDefinitionId}/versions/{ResourceDefinitionVersionId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about a resource definition version, including which resources are included in the version.
    ///
    /// Parameters:
    ///   - resourceDefinitionId: The ID of the resource definition.
    ///   - resourceDefinitionVersionId: The ID of the resource definition version. This value maps to the ''Version'' property of the corresponding ''VersionInformation'' object, which is returned by ''ListResourceDefinitionVersions'' requests. If the version is the last one that was associated with a resource definition, the value also maps to the ''LatestVersion'' property of the corresponding ''DefinitionInformation'' object.
    ///   - logger: Logger use during operation
    @inlinable
    public func getResourceDefinitionVersion(
        resourceDefinitionId: String,
        resourceDefinitionVersionId: String,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> GetResourceDefinitionVersionResponse {
        let input = GetResourceDefinitionVersionRequest(
            resourceDefinitionId: resourceDefinitionId, 
            resourceDefinitionVersionId: resourceDefinitionVersionId
        )
        return try await self.getResourceDefinitionVersion(input, logger: logger)
    }

    /// Retrieves the service role that is attached to your account.
    @Sendable
    @inlinable
    public func getServiceRoleForAccount(_ input: GetServiceRoleForAccountRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> GetServiceRoleForAccountResponse {
        try await self.client.execute(
            operation: "GetServiceRoleForAccount", 
            path: "/greengrass/servicerole", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves the service role that is attached to your account.
    ///
    /// Parameters:
    ///   - logger: Logger use during operation
    @inlinable
    public func getServiceRoleForAccount(
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> GetServiceRoleForAccountResponse {
        let input = GetServiceRoleForAccountRequest(
        )
        return try await self.getServiceRoleForAccount(input, logger: logger)
    }

    /// Retrieves information about a subscription definition.
    @Sendable
    @inlinable
    public func getSubscriptionDefinition(_ input: GetSubscriptionDefinitionRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> GetSubscriptionDefinitionResponse {
        try await self.client.execute(
            operation: "GetSubscriptionDefinition", 
            path: "/greengrass/definition/subscriptions/{SubscriptionDefinitionId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about a subscription definition.
    ///
    /// Parameters:
    ///   - subscriptionDefinitionId: The ID of the subscription definition.
    ///   - logger: Logger use during operation
    @inlinable
    public func getSubscriptionDefinition(
        subscriptionDefinitionId: String,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> GetSubscriptionDefinitionResponse {
        let input = GetSubscriptionDefinitionRequest(
            subscriptionDefinitionId: subscriptionDefinitionId
        )
        return try await self.getSubscriptionDefinition(input, logger: logger)
    }

    /// Retrieves information about a subscription definition version.
    @Sendable
    @inlinable
    public func getSubscriptionDefinitionVersion(_ input: GetSubscriptionDefinitionVersionRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> GetSubscriptionDefinitionVersionResponse {
        try await self.client.execute(
            operation: "GetSubscriptionDefinitionVersion", 
            path: "/greengrass/definition/subscriptions/{SubscriptionDefinitionId}/versions/{SubscriptionDefinitionVersionId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about a subscription definition version.
    ///
    /// Parameters:
    ///   - nextToken: The token for the next set of results, or ''null'' if there are no additional results.
    ///   - subscriptionDefinitionId: The ID of the subscription definition.
    ///   - subscriptionDefinitionVersionId: The ID of the subscription definition version. This value maps to the ''Version'' property of the corresponding ''VersionInformation'' object, which is returned by ''ListSubscriptionDefinitionVersions'' requests. If the version is the last one that was associated with a subscription definition, the value also maps to the ''LatestVersion'' property of the corresponding ''DefinitionInformation'' object.
    ///   - logger: Logger use during operation
    @inlinable
    public func getSubscriptionDefinitionVersion(
        nextToken: String? = nil,
        subscriptionDefinitionId: String,
        subscriptionDefinitionVersionId: String,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> GetSubscriptionDefinitionVersionResponse {
        let input = GetSubscriptionDefinitionVersionRequest(
            nextToken: nextToken, 
            subscriptionDefinitionId: subscriptionDefinitionId, 
            subscriptionDefinitionVersionId: subscriptionDefinitionVersionId
        )
        return try await self.getSubscriptionDefinitionVersion(input, logger: logger)
    }

    /// Get the runtime configuration of a thing.
    @Sendable
    @inlinable
    public func getThingRuntimeConfiguration(_ input: GetThingRuntimeConfigurationRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> GetThingRuntimeConfigurationResponse {
        try await self.client.execute(
            operation: "GetThingRuntimeConfiguration", 
            path: "/greengrass/things/{ThingName}/runtimeconfig", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Get the runtime configuration of a thing.
    ///
    /// Parameters:
    ///   - thingName: The thing name.
    ///   - logger: Logger use during operation
    @inlinable
    public func getThingRuntimeConfiguration(
        thingName: String,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> GetThingRuntimeConfigurationResponse {
        let input = GetThingRuntimeConfigurationRequest(
            thingName: thingName
        )
        return try await self.getThingRuntimeConfiguration(input, logger: logger)
    }

    /// Gets a paginated list of the deployments that have been started in a bulk deployment operation, and their current deployment status.
    @Sendable
    @inlinable
    public func listBulkDeploymentDetailedReports(_ input: ListBulkDeploymentDetailedReportsRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> ListBulkDeploymentDetailedReportsResponse {
        try await self.client.execute(
            operation: "ListBulkDeploymentDetailedReports", 
            path: "/greengrass/bulk/deployments/{BulkDeploymentId}/detailed-reports", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets a paginated list of the deployments that have been started in a bulk deployment operation, and their current deployment status.
    ///
    /// Parameters:
    ///   - bulkDeploymentId: The ID of the bulk deployment.
    ///   - maxResults: The maximum number of results to be returned per request.
    ///   - nextToken: The token for the next set of results, or ''null'' if there are no additional results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listBulkDeploymentDetailedReports(
        bulkDeploymentId: String,
        maxResults: String? = nil,
        nextToken: String? = nil,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> ListBulkDeploymentDetailedReportsResponse {
        let input = ListBulkDeploymentDetailedReportsRequest(
            bulkDeploymentId: bulkDeploymentId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listBulkDeploymentDetailedReports(input, logger: logger)
    }

    /// Returns a list of bulk deployments.
    @Sendable
    @inlinable
    public func listBulkDeployments(_ input: ListBulkDeploymentsRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> ListBulkDeploymentsResponse {
        try await self.client.execute(
            operation: "ListBulkDeployments", 
            path: "/greengrass/bulk/deployments", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a list of bulk deployments.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to be returned per request.
    ///   - nextToken: The token for the next set of results, or ''null'' if there are no additional results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listBulkDeployments(
        maxResults: String? = nil,
        nextToken: String? = nil,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> ListBulkDeploymentsResponse {
        let input = ListBulkDeploymentsRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listBulkDeployments(input, logger: logger)
    }

    /// Lists the versions of a connector definition, which are containers for connectors. Connectors run on the Greengrass core and contain built-in integration with local infrastructure, device protocols, AWS, and other cloud services.
    @Sendable
    @inlinable
    public func listConnectorDefinitionVersions(_ input: ListConnectorDefinitionVersionsRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> ListConnectorDefinitionVersionsResponse {
        try await self.client.execute(
            operation: "ListConnectorDefinitionVersions", 
            path: "/greengrass/definition/connectors/{ConnectorDefinitionId}/versions", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the versions of a connector definition, which are containers for connectors. Connectors run on the Greengrass core and contain built-in integration with local infrastructure, device protocols, AWS, and other cloud services.
    ///
    /// Parameters:
    ///   - connectorDefinitionId: The ID of the connector definition.
    ///   - maxResults: The maximum number of results to be returned per request.
    ///   - nextToken: The token for the next set of results, or ''null'' if there are no additional results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listConnectorDefinitionVersions(
        connectorDefinitionId: String,
        maxResults: String? = nil,
        nextToken: String? = nil,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> ListConnectorDefinitionVersionsResponse {
        let input = ListConnectorDefinitionVersionsRequest(
            connectorDefinitionId: connectorDefinitionId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listConnectorDefinitionVersions(input, logger: logger)
    }

    /// Retrieves a list of connector definitions.
    @Sendable
    @inlinable
    public func listConnectorDefinitions(_ input: ListConnectorDefinitionsRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> ListConnectorDefinitionsResponse {
        try await self.client.execute(
            operation: "ListConnectorDefinitions", 
            path: "/greengrass/definition/connectors", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves a list of connector definitions.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to be returned per request.
    ///   - nextToken: The token for the next set of results, or ''null'' if there are no additional results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listConnectorDefinitions(
        maxResults: String? = nil,
        nextToken: String? = nil,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> ListConnectorDefinitionsResponse {
        let input = ListConnectorDefinitionsRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listConnectorDefinitions(input, logger: logger)
    }

    /// Lists the versions of a core definition.
    @Sendable
    @inlinable
    public func listCoreDefinitionVersions(_ input: ListCoreDefinitionVersionsRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> ListCoreDefinitionVersionsResponse {
        try await self.client.execute(
            operation: "ListCoreDefinitionVersions", 
            path: "/greengrass/definition/cores/{CoreDefinitionId}/versions", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the versions of a core definition.
    ///
    /// Parameters:
    ///   - coreDefinitionId: The ID of the core definition.
    ///   - maxResults: The maximum number of results to be returned per request.
    ///   - nextToken: The token for the next set of results, or ''null'' if there are no additional results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listCoreDefinitionVersions(
        coreDefinitionId: String,
        maxResults: String? = nil,
        nextToken: String? = nil,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> ListCoreDefinitionVersionsResponse {
        let input = ListCoreDefinitionVersionsRequest(
            coreDefinitionId: coreDefinitionId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listCoreDefinitionVersions(input, logger: logger)
    }

    /// Retrieves a list of core definitions.
    @Sendable
    @inlinable
    public func listCoreDefinitions(_ input: ListCoreDefinitionsRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> ListCoreDefinitionsResponse {
        try await self.client.execute(
            operation: "ListCoreDefinitions", 
            path: "/greengrass/definition/cores", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves a list of core definitions.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to be returned per request.
    ///   - nextToken: The token for the next set of results, or ''null'' if there are no additional results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listCoreDefinitions(
        maxResults: String? = nil,
        nextToken: String? = nil,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> ListCoreDefinitionsResponse {
        let input = ListCoreDefinitionsRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listCoreDefinitions(input, logger: logger)
    }

    /// Returns a history of deployments for the group.
    @Sendable
    @inlinable
    public func listDeployments(_ input: ListDeploymentsRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> ListDeploymentsResponse {
        try await self.client.execute(
            operation: "ListDeployments", 
            path: "/greengrass/groups/{GroupId}/deployments", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a history of deployments for the group.
    ///
    /// Parameters:
    ///   - groupId: The ID of the Greengrass group.
    ///   - maxResults: The maximum number of results to be returned per request.
    ///   - nextToken: The token for the next set of results, or ''null'' if there are no additional results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listDeployments(
        groupId: String,
        maxResults: String? = nil,
        nextToken: String? = nil,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> ListDeploymentsResponse {
        let input = ListDeploymentsRequest(
            groupId: groupId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listDeployments(input, logger: logger)
    }

    /// Lists the versions of a device definition.
    @Sendable
    @inlinable
    public func listDeviceDefinitionVersions(_ input: ListDeviceDefinitionVersionsRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> ListDeviceDefinitionVersionsResponse {
        try await self.client.execute(
            operation: "ListDeviceDefinitionVersions", 
            path: "/greengrass/definition/devices/{DeviceDefinitionId}/versions", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the versions of a device definition.
    ///
    /// Parameters:
    ///   - deviceDefinitionId: The ID of the device definition.
    ///   - maxResults: The maximum number of results to be returned per request.
    ///   - nextToken: The token for the next set of results, or ''null'' if there are no additional results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listDeviceDefinitionVersions(
        deviceDefinitionId: String,
        maxResults: String? = nil,
        nextToken: String? = nil,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> ListDeviceDefinitionVersionsResponse {
        let input = ListDeviceDefinitionVersionsRequest(
            deviceDefinitionId: deviceDefinitionId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listDeviceDefinitionVersions(input, logger: logger)
    }

    /// Retrieves a list of device definitions.
    @Sendable
    @inlinable
    public func listDeviceDefinitions(_ input: ListDeviceDefinitionsRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> ListDeviceDefinitionsResponse {
        try await self.client.execute(
            operation: "ListDeviceDefinitions", 
            path: "/greengrass/definition/devices", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves a list of device definitions.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to be returned per request.
    ///   - nextToken: The token for the next set of results, or ''null'' if there are no additional results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listDeviceDefinitions(
        maxResults: String? = nil,
        nextToken: String? = nil,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> ListDeviceDefinitionsResponse {
        let input = ListDeviceDefinitionsRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listDeviceDefinitions(input, logger: logger)
    }

    /// Lists the versions of a Lambda function definition.
    @Sendable
    @inlinable
    public func listFunctionDefinitionVersions(_ input: ListFunctionDefinitionVersionsRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> ListFunctionDefinitionVersionsResponse {
        try await self.client.execute(
            operation: "ListFunctionDefinitionVersions", 
            path: "/greengrass/definition/functions/{FunctionDefinitionId}/versions", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the versions of a Lambda function definition.
    ///
    /// Parameters:
    ///   - functionDefinitionId: The ID of the Lambda function definition.
    ///   - maxResults: The maximum number of results to be returned per request.
    ///   - nextToken: The token for the next set of results, or ''null'' if there are no additional results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listFunctionDefinitionVersions(
        functionDefinitionId: String,
        maxResults: String? = nil,
        nextToken: String? = nil,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> ListFunctionDefinitionVersionsResponse {
        let input = ListFunctionDefinitionVersionsRequest(
            functionDefinitionId: functionDefinitionId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listFunctionDefinitionVersions(input, logger: logger)
    }

    /// Retrieves a list of Lambda function definitions.
    @Sendable
    @inlinable
    public func listFunctionDefinitions(_ input: ListFunctionDefinitionsRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> ListFunctionDefinitionsResponse {
        try await self.client.execute(
            operation: "ListFunctionDefinitions", 
            path: "/greengrass/definition/functions", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves a list of Lambda function definitions.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to be returned per request.
    ///   - nextToken: The token for the next set of results, or ''null'' if there are no additional results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listFunctionDefinitions(
        maxResults: String? = nil,
        nextToken: String? = nil,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> ListFunctionDefinitionsResponse {
        let input = ListFunctionDefinitionsRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listFunctionDefinitions(input, logger: logger)
    }

    /// Retrieves the current CAs for a group.
    @Sendable
    @inlinable
    public func listGroupCertificateAuthorities(_ input: ListGroupCertificateAuthoritiesRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> ListGroupCertificateAuthoritiesResponse {
        try await self.client.execute(
            operation: "ListGroupCertificateAuthorities", 
            path: "/greengrass/groups/{GroupId}/certificateauthorities", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves the current CAs for a group.
    ///
    /// Parameters:
    ///   - groupId: The ID of the Greengrass group.
    ///   - logger: Logger use during operation
    @inlinable
    public func listGroupCertificateAuthorities(
        groupId: String,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> ListGroupCertificateAuthoritiesResponse {
        let input = ListGroupCertificateAuthoritiesRequest(
            groupId: groupId
        )
        return try await self.listGroupCertificateAuthorities(input, logger: logger)
    }

    /// Lists the versions of a group.
    @Sendable
    @inlinable
    public func listGroupVersions(_ input: ListGroupVersionsRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> ListGroupVersionsResponse {
        try await self.client.execute(
            operation: "ListGroupVersions", 
            path: "/greengrass/groups/{GroupId}/versions", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the versions of a group.
    ///
    /// Parameters:
    ///   - groupId: The ID of the Greengrass group.
    ///   - maxResults: The maximum number of results to be returned per request.
    ///   - nextToken: The token for the next set of results, or ''null'' if there are no additional results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listGroupVersions(
        groupId: String,
        maxResults: String? = nil,
        nextToken: String? = nil,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> ListGroupVersionsResponse {
        let input = ListGroupVersionsRequest(
            groupId: groupId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listGroupVersions(input, logger: logger)
    }

    /// Retrieves a list of groups.
    @Sendable
    @inlinable
    public func listGroups(_ input: ListGroupsRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> ListGroupsResponse {
        try await self.client.execute(
            operation: "ListGroups", 
            path: "/greengrass/groups", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves a list of groups.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to be returned per request.
    ///   - nextToken: The token for the next set of results, or ''null'' if there are no additional results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listGroups(
        maxResults: String? = nil,
        nextToken: String? = nil,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> ListGroupsResponse {
        let input = ListGroupsRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listGroups(input, logger: logger)
    }

    /// Lists the versions of a logger definition.
    @Sendable
    @inlinable
    public func listLoggerDefinitionVersions(_ input: ListLoggerDefinitionVersionsRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> ListLoggerDefinitionVersionsResponse {
        try await self.client.execute(
            operation: "ListLoggerDefinitionVersions", 
            path: "/greengrass/definition/loggers/{LoggerDefinitionId}/versions", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the versions of a logger definition.
    ///
    /// Parameters:
    ///   - loggerDefinitionId: The ID of the logger definition.
    ///   - maxResults: The maximum number of results to be returned per request.
    ///   - nextToken: The token for the next set of results, or ''null'' if there are no additional results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listLoggerDefinitionVersions(
        loggerDefinitionId: String,
        maxResults: String? = nil,
        nextToken: String? = nil,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> ListLoggerDefinitionVersionsResponse {
        let input = ListLoggerDefinitionVersionsRequest(
            loggerDefinitionId: loggerDefinitionId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listLoggerDefinitionVersions(input, logger: logger)
    }

    /// Retrieves a list of logger definitions.
    @Sendable
    @inlinable
    public func listLoggerDefinitions(_ input: ListLoggerDefinitionsRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> ListLoggerDefinitionsResponse {
        try await self.client.execute(
            operation: "ListLoggerDefinitions", 
            path: "/greengrass/definition/loggers", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves a list of logger definitions.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to be returned per request.
    ///   - nextToken: The token for the next set of results, or ''null'' if there are no additional results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listLoggerDefinitions(
        maxResults: String? = nil,
        nextToken: String? = nil,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> ListLoggerDefinitionsResponse {
        let input = ListLoggerDefinitionsRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listLoggerDefinitions(input, logger: logger)
    }

    /// Lists the versions of a resource definition.
    @Sendable
    @inlinable
    public func listResourceDefinitionVersions(_ input: ListResourceDefinitionVersionsRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> ListResourceDefinitionVersionsResponse {
        try await self.client.execute(
            operation: "ListResourceDefinitionVersions", 
            path: "/greengrass/definition/resources/{ResourceDefinitionId}/versions", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the versions of a resource definition.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to be returned per request.
    ///   - nextToken: The token for the next set of results, or ''null'' if there are no additional results.
    ///   - resourceDefinitionId: The ID of the resource definition.
    ///   - logger: Logger use during operation
    @inlinable
    public func listResourceDefinitionVersions(
        maxResults: String? = nil,
        nextToken: String? = nil,
        resourceDefinitionId: String,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> ListResourceDefinitionVersionsResponse {
        let input = ListResourceDefinitionVersionsRequest(
            maxResults: maxResults, 
            nextToken: nextToken, 
            resourceDefinitionId: resourceDefinitionId
        )
        return try await self.listResourceDefinitionVersions(input, logger: logger)
    }

    /// Retrieves a list of resource definitions.
    @Sendable
    @inlinable
    public func listResourceDefinitions(_ input: ListResourceDefinitionsRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> ListResourceDefinitionsResponse {
        try await self.client.execute(
            operation: "ListResourceDefinitions", 
            path: "/greengrass/definition/resources", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves a list of resource definitions.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to be returned per request.
    ///   - nextToken: The token for the next set of results, or ''null'' if there are no additional results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listResourceDefinitions(
        maxResults: String? = nil,
        nextToken: String? = nil,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> ListResourceDefinitionsResponse {
        let input = ListResourceDefinitionsRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listResourceDefinitions(input, logger: logger)
    }

    /// Lists the versions of a subscription definition.
    @Sendable
    @inlinable
    public func listSubscriptionDefinitionVersions(_ input: ListSubscriptionDefinitionVersionsRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> ListSubscriptionDefinitionVersionsResponse {
        try await self.client.execute(
            operation: "ListSubscriptionDefinitionVersions", 
            path: "/greengrass/definition/subscriptions/{SubscriptionDefinitionId}/versions", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the versions of a subscription definition.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to be returned per request.
    ///   - nextToken: The token for the next set of results, or ''null'' if there are no additional results.
    ///   - subscriptionDefinitionId: The ID of the subscription definition.
    ///   - logger: Logger use during operation
    @inlinable
    public func listSubscriptionDefinitionVersions(
        maxResults: String? = nil,
        nextToken: String? = nil,
        subscriptionDefinitionId: String,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> ListSubscriptionDefinitionVersionsResponse {
        let input = ListSubscriptionDefinitionVersionsRequest(
            maxResults: maxResults, 
            nextToken: nextToken, 
            subscriptionDefinitionId: subscriptionDefinitionId
        )
        return try await self.listSubscriptionDefinitionVersions(input, logger: logger)
    }

    /// Retrieves a list of subscription definitions.
    @Sendable
    @inlinable
    public func listSubscriptionDefinitions(_ input: ListSubscriptionDefinitionsRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> ListSubscriptionDefinitionsResponse {
        try await self.client.execute(
            operation: "ListSubscriptionDefinitions", 
            path: "/greengrass/definition/subscriptions", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves a list of subscription definitions.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to be returned per request.
    ///   - nextToken: The token for the next set of results, or ''null'' if there are no additional results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listSubscriptionDefinitions(
        maxResults: String? = nil,
        nextToken: String? = nil,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> ListSubscriptionDefinitionsResponse {
        let input = ListSubscriptionDefinitionsRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listSubscriptionDefinitions(input, logger: logger)
    }

    /// Retrieves a list of resource tags for a resource arn.
    @Sendable
    @inlinable
    public func listTagsForResource(_ input: ListTagsForResourceRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> ListTagsForResourceResponse {
        try await self.client.execute(
            operation: "ListTagsForResource", 
            path: "/tags/{ResourceArn}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves a list of resource tags for a resource arn.
    ///
    /// Parameters:
    ///   - resourceArn: The Amazon Resource Name (ARN) of the resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func listTagsForResource(
        resourceArn: String,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> ListTagsForResourceResponse {
        let input = ListTagsForResourceRequest(
            resourceArn: resourceArn
        )
        return try await self.listTagsForResource(input, logger: logger)
    }

    /// Resets a group's deployments.
    @Sendable
    @inlinable
    public func resetDeployments(_ input: ResetDeploymentsRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> ResetDeploymentsResponse {
        try await self.client.execute(
            operation: "ResetDeployments", 
            path: "/greengrass/groups/{GroupId}/deployments/$reset", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Resets a group's deployments.
    ///
    /// Parameters:
    ///   - amznClientToken: A client token used to correlate requests and responses.
    ///   - force: If true, performs a best-effort only core reset.
    ///   - groupId: The ID of the Greengrass group.
    ///   - logger: Logger use during operation
    @inlinable
    public func resetDeployments(
        amznClientToken: String? = nil,
        force: Bool? = nil,
        groupId: String,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> ResetDeploymentsResponse {
        let input = ResetDeploymentsRequest(
            amznClientToken: amznClientToken, 
            force: force, 
            groupId: groupId
        )
        return try await self.resetDeployments(input, logger: logger)
    }

    /// Deploys multiple groups in one operation. This action starts the bulk deployment of a specified set of group versions. Each group version deployment will be triggered with an adaptive rate that has a fixed upper limit. We recommend that you include an ''X-Amzn-Client-Token'' token in every ''StartBulkDeployment'' request. These requests are idempotent with respect to the token and the request parameters.
    @Sendable
    @inlinable
    public func startBulkDeployment(_ input: StartBulkDeploymentRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> StartBulkDeploymentResponse {
        try await self.client.execute(
            operation: "StartBulkDeployment", 
            path: "/greengrass/bulk/deployments", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deploys multiple groups in one operation. This action starts the bulk deployment of a specified set of group versions. Each group version deployment will be triggered with an adaptive rate that has a fixed upper limit. We recommend that you include an ''X-Amzn-Client-Token'' token in every ''StartBulkDeployment'' request. These requests are idempotent with respect to the token and the request parameters.
    ///
    /// Parameters:
    ///   - amznClientToken: A client token used to correlate requests and responses.
    ///   - executionRoleArn: The ARN of the execution role to associate with the bulk deployment operation. This IAM role must allow the ''greengrass:CreateDeployment'' action for all group versions that are listed in the input file. This IAM role must have access to the S3 bucket containing the input file.
    ///   - inputFileUri: The URI of the input file contained in the S3 bucket. The execution role must have ''getObject'' permissions on this bucket to access the input file. The input file is a JSON-serialized, line delimited file with UTF-8 encoding that provides a list of group and version IDs and the deployment type. This file must be less than 100 MB. Currently, AWS IoT Greengrass supports only ''NewDeployment'' deployment types.
    ///   - tags: Tag(s) to add to the new resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func startBulkDeployment(
        amznClientToken: String? = nil,
        executionRoleArn: String? = nil,
        inputFileUri: String? = nil,
        tags: [String: String]? = nil,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> StartBulkDeploymentResponse {
        let input = StartBulkDeploymentRequest(
            amznClientToken: amznClientToken, 
            executionRoleArn: executionRoleArn, 
            inputFileUri: inputFileUri, 
            tags: tags
        )
        return try await self.startBulkDeployment(input, logger: logger)
    }

    /// Stops the execution of a bulk deployment. This action returns a status of ''Stopping'' until the deployment is stopped. You cannot start a new bulk deployment while a previous deployment is in the ''Stopping'' state. This action doesn't rollback completed deployments or cancel pending deployments.
    @Sendable
    @inlinable
    public func stopBulkDeployment(_ input: StopBulkDeploymentRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> StopBulkDeploymentResponse {
        try await self.client.execute(
            operation: "StopBulkDeployment", 
            path: "/greengrass/bulk/deployments/{BulkDeploymentId}/$stop", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Stops the execution of a bulk deployment. This action returns a status of ''Stopping'' until the deployment is stopped. You cannot start a new bulk deployment while a previous deployment is in the ''Stopping'' state. This action doesn't rollback completed deployments or cancel pending deployments.
    ///
    /// Parameters:
    ///   - bulkDeploymentId: The ID of the bulk deployment.
    ///   - logger: Logger use during operation
    @inlinable
    public func stopBulkDeployment(
        bulkDeploymentId: String,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> StopBulkDeploymentResponse {
        let input = StopBulkDeploymentRequest(
            bulkDeploymentId: bulkDeploymentId
        )
        return try await self.stopBulkDeployment(input, logger: logger)
    }

    /// Adds tags to a Greengrass resource. Valid resources are 'Group', 'ConnectorDefinition', 'CoreDefinition', 'DeviceDefinition', 'FunctionDefinition', 'LoggerDefinition', 'SubscriptionDefinition', 'ResourceDefinition', and 'BulkDeployment'.
    @Sendable
    @inlinable
    public func tagResource(_ input: TagResourceRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "TagResource", 
            path: "/tags/{ResourceArn}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Adds tags to a Greengrass resource. Valid resources are 'Group', 'ConnectorDefinition', 'CoreDefinition', 'DeviceDefinition', 'FunctionDefinition', 'LoggerDefinition', 'SubscriptionDefinition', 'ResourceDefinition', and 'BulkDeployment'.
    ///
    /// Parameters:
    ///   - resourceArn: The Amazon Resource Name (ARN) of the resource.
    ///   - tags: 
    ///   - logger: Logger use during operation
    @inlinable
    public func tagResource(
        resourceArn: String,
        tags: [String: String]? = nil,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = TagResourceRequest(
            resourceArn: resourceArn, 
            tags: tags
        )
        return try await self.tagResource(input, logger: logger)
    }

    /// Remove resource tags from a Greengrass Resource.
    @Sendable
    @inlinable
    public func untagResource(_ input: UntagResourceRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "UntagResource", 
            path: "/tags/{ResourceArn}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Remove resource tags from a Greengrass Resource.
    ///
    /// Parameters:
    ///   - resourceArn: The Amazon Resource Name (ARN) of the resource.
    ///   - tagKeys: An array of tag keys to delete
    ///   - logger: Logger use during operation
    @inlinable
    public func untagResource(
        resourceArn: String,
        tagKeys: [String]? = nil,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = UntagResourceRequest(
            resourceArn: resourceArn, 
            tagKeys: tagKeys
        )
        return try await self.untagResource(input, logger: logger)
    }

    /// Updates the connectivity information for the core. Any devices that belong to the group which has this core will receive this information in order to find the location of the core and connect to it.
    @Sendable
    @inlinable
    public func updateConnectivityInfo(_ input: UpdateConnectivityInfoRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> UpdateConnectivityInfoResponse {
        try await self.client.execute(
            operation: "UpdateConnectivityInfo", 
            path: "/greengrass/things/{ThingName}/connectivityInfo", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the connectivity information for the core. Any devices that belong to the group which has this core will receive this information in order to find the location of the core and connect to it.
    ///
    /// Parameters:
    ///   - connectivityInfo: A list of connectivity info.
    ///   - thingName: The thing name.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateConnectivityInfo(
        connectivityInfo: [ConnectivityInfo]? = nil,
        thingName: String,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateConnectivityInfoResponse {
        let input = UpdateConnectivityInfoRequest(
            connectivityInfo: connectivityInfo, 
            thingName: thingName
        )
        return try await self.updateConnectivityInfo(input, logger: logger)
    }

    /// Updates a connector definition.
    @Sendable
    @inlinable
    public func updateConnectorDefinition(_ input: UpdateConnectorDefinitionRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> UpdateConnectorDefinitionResponse {
        try await self.client.execute(
            operation: "UpdateConnectorDefinition", 
            path: "/greengrass/definition/connectors/{ConnectorDefinitionId}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates a connector definition.
    ///
    /// Parameters:
    ///   - connectorDefinitionId: The ID of the connector definition.
    ///   - name: The name of the definition.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateConnectorDefinition(
        connectorDefinitionId: String,
        name: String? = nil,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateConnectorDefinitionResponse {
        let input = UpdateConnectorDefinitionRequest(
            connectorDefinitionId: connectorDefinitionId, 
            name: name
        )
        return try await self.updateConnectorDefinition(input, logger: logger)
    }

    /// Updates a core definition.
    @Sendable
    @inlinable
    public func updateCoreDefinition(_ input: UpdateCoreDefinitionRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> UpdateCoreDefinitionResponse {
        try await self.client.execute(
            operation: "UpdateCoreDefinition", 
            path: "/greengrass/definition/cores/{CoreDefinitionId}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates a core definition.
    ///
    /// Parameters:
    ///   - coreDefinitionId: The ID of the core definition.
    ///   - name: The name of the definition.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateCoreDefinition(
        coreDefinitionId: String,
        name: String? = nil,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateCoreDefinitionResponse {
        let input = UpdateCoreDefinitionRequest(
            coreDefinitionId: coreDefinitionId, 
            name: name
        )
        return try await self.updateCoreDefinition(input, logger: logger)
    }

    /// Updates a device definition.
    @Sendable
    @inlinable
    public func updateDeviceDefinition(_ input: UpdateDeviceDefinitionRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> UpdateDeviceDefinitionResponse {
        try await self.client.execute(
            operation: "UpdateDeviceDefinition", 
            path: "/greengrass/definition/devices/{DeviceDefinitionId}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates a device definition.
    ///
    /// Parameters:
    ///   - deviceDefinitionId: The ID of the device definition.
    ///   - name: The name of the definition.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateDeviceDefinition(
        deviceDefinitionId: String,
        name: String? = nil,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateDeviceDefinitionResponse {
        let input = UpdateDeviceDefinitionRequest(
            deviceDefinitionId: deviceDefinitionId, 
            name: name
        )
        return try await self.updateDeviceDefinition(input, logger: logger)
    }

    /// Updates a Lambda function definition.
    @Sendable
    @inlinable
    public func updateFunctionDefinition(_ input: UpdateFunctionDefinitionRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> UpdateFunctionDefinitionResponse {
        try await self.client.execute(
            operation: "UpdateFunctionDefinition", 
            path: "/greengrass/definition/functions/{FunctionDefinitionId}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates a Lambda function definition.
    ///
    /// Parameters:
    ///   - functionDefinitionId: The ID of the Lambda function definition.
    ///   - name: The name of the definition.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateFunctionDefinition(
        functionDefinitionId: String,
        name: String? = nil,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateFunctionDefinitionResponse {
        let input = UpdateFunctionDefinitionRequest(
            functionDefinitionId: functionDefinitionId, 
            name: name
        )
        return try await self.updateFunctionDefinition(input, logger: logger)
    }

    /// Updates a group.
    @Sendable
    @inlinable
    public func updateGroup(_ input: UpdateGroupRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> UpdateGroupResponse {
        try await self.client.execute(
            operation: "UpdateGroup", 
            path: "/greengrass/groups/{GroupId}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates a group.
    ///
    /// Parameters:
    ///   - groupId: The ID of the Greengrass group.
    ///   - name: The name of the definition.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateGroup(
        groupId: String,
        name: String? = nil,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateGroupResponse {
        let input = UpdateGroupRequest(
            groupId: groupId, 
            name: name
        )
        return try await self.updateGroup(input, logger: logger)
    }

    /// Updates the Certificate expiry time for a group.
    @Sendable
    @inlinable
    public func updateGroupCertificateConfiguration(_ input: UpdateGroupCertificateConfigurationRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> UpdateGroupCertificateConfigurationResponse {
        try await self.client.execute(
            operation: "UpdateGroupCertificateConfiguration", 
            path: "/greengrass/groups/{GroupId}/certificateauthorities/configuration/expiry", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the Certificate expiry time for a group.
    ///
    /// Parameters:
    ///   - certificateExpiryInMilliseconds: The amount of time remaining before the certificate expires, in milliseconds.
    ///   - groupId: The ID of the Greengrass group.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateGroupCertificateConfiguration(
        certificateExpiryInMilliseconds: String? = nil,
        groupId: String,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateGroupCertificateConfigurationResponse {
        let input = UpdateGroupCertificateConfigurationRequest(
            certificateExpiryInMilliseconds: certificateExpiryInMilliseconds, 
            groupId: groupId
        )
        return try await self.updateGroupCertificateConfiguration(input, logger: logger)
    }

    /// Updates a logger definition.
    @Sendable
    @inlinable
    public func updateLoggerDefinition(_ input: UpdateLoggerDefinitionRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> UpdateLoggerDefinitionResponse {
        try await self.client.execute(
            operation: "UpdateLoggerDefinition", 
            path: "/greengrass/definition/loggers/{LoggerDefinitionId}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates a logger definition.
    ///
    /// Parameters:
    ///   - loggerDefinitionId: The ID of the logger definition.
    ///   - name: The name of the definition.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateLoggerDefinition(
        loggerDefinitionId: String,
        name: String? = nil,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateLoggerDefinitionResponse {
        let input = UpdateLoggerDefinitionRequest(
            loggerDefinitionId: loggerDefinitionId, 
            name: name
        )
        return try await self.updateLoggerDefinition(input, logger: logger)
    }

    /// Updates a resource definition.
    @Sendable
    @inlinable
    public func updateResourceDefinition(_ input: UpdateResourceDefinitionRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> UpdateResourceDefinitionResponse {
        try await self.client.execute(
            operation: "UpdateResourceDefinition", 
            path: "/greengrass/definition/resources/{ResourceDefinitionId}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates a resource definition.
    ///
    /// Parameters:
    ///   - name: The name of the definition.
    ///   - resourceDefinitionId: The ID of the resource definition.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateResourceDefinition(
        name: String? = nil,
        resourceDefinitionId: String,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateResourceDefinitionResponse {
        let input = UpdateResourceDefinitionRequest(
            name: name, 
            resourceDefinitionId: resourceDefinitionId
        )
        return try await self.updateResourceDefinition(input, logger: logger)
    }

    /// Updates a subscription definition.
    @Sendable
    @inlinable
    public func updateSubscriptionDefinition(_ input: UpdateSubscriptionDefinitionRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> UpdateSubscriptionDefinitionResponse {
        try await self.client.execute(
            operation: "UpdateSubscriptionDefinition", 
            path: "/greengrass/definition/subscriptions/{SubscriptionDefinitionId}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates a subscription definition.
    ///
    /// Parameters:
    ///   - name: The name of the definition.
    ///   - subscriptionDefinitionId: The ID of the subscription definition.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateSubscriptionDefinition(
        name: String? = nil,
        subscriptionDefinitionId: String,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateSubscriptionDefinitionResponse {
        let input = UpdateSubscriptionDefinitionRequest(
            name: name, 
            subscriptionDefinitionId: subscriptionDefinitionId
        )
        return try await self.updateSubscriptionDefinition(input, logger: logger)
    }

    /// Updates the runtime configuration of a thing.
    @Sendable
    @inlinable
    public func updateThingRuntimeConfiguration(_ input: UpdateThingRuntimeConfigurationRequest, logger: Logging.Logger = AWSClient.loggingDisabled) async throws -> UpdateThingRuntimeConfigurationResponse {
        try await self.client.execute(
            operation: "UpdateThingRuntimeConfiguration", 
            path: "/greengrass/things/{ThingName}/runtimeconfig", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the runtime configuration of a thing.
    ///
    /// Parameters:
    ///   - telemetryConfiguration: Configuration for telemetry service.
    ///   - thingName: The thing name.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateThingRuntimeConfiguration(
        telemetryConfiguration: TelemetryConfigurationUpdate? = nil,
        thingName: String,
        logger: Logging.Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateThingRuntimeConfigurationResponse {
        let input = UpdateThingRuntimeConfigurationRequest(
            telemetryConfiguration: telemetryConfiguration, 
            thingName: thingName
        )
        return try await self.updateThingRuntimeConfiguration(input, logger: logger)
    }
}

extension Greengrass {
    /// Initializer required by `AWSService.with(middlewares:timeout:byteBufferAllocator:options)`. You are not able to use this initializer directly as there are not public
    /// initializers for `AWSServiceConfig.Patch`. Please use `AWSService.with(middlewares:timeout:byteBufferAllocator:options)` instead.
    public init(from: Greengrass, patch: AWSServiceConfig.Patch) {
        self.client = from.client
        self.config = from.config.with(patch: patch)
    }
}
